/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
 
This file is part of Quake III Arena source code.
 
Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
 
Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
//

/*****************************************************************************
 * name:		ai_team.c
 *
 * desc:		Quake3 bot AI
 *
 * $Archive: /code/game/ai_team.c $
 *
 *****************************************************************************/

#include "g_local.h"
#include "botlib.h"
#include "be_aas.h"
#include "be_ea.h"
#include "be_ai_char.h"
#include "be_ai_chat.h"
#include "be_ai_gen.h"
#include "be_ai_goal.h"
#include "be_ai_move.h"
#include "be_ai_weap.h"
//
#include "ai_main.h"
#include "ai_dmq3.h"
#include "ai_chat.h"
#include "ai_cmd.h"
#include "ai_dmnet.h"
#include "ai_team.h"
#include "ai_vcmd.h"

#include "match.h"

// for the voice chats
#include "../ui/menudef.h"

//ctf task preferences for a client
typedef struct bot_ctftaskpreference_s
{
    char		name[36];
    int			preference;
}
bot_ctftaskpreference_t;

bot_ctftaskpreference_t ctftaskpreferences[MAX_CLIENTS];


/*
==================
BotValidTeamLeader
==================
*/
int BotValidTeamLeader(bot_state_t *bs)
{
    if (!strlen(bs->teamleader)) return qfalse;
    if (ClientFromName(bs->teamleader) == -1) return qfalse;
    return qtrue;
}

/*
==================
BotNumTeamMates
==================
*/
int BotNumTeamMates(bot_state_t *bs)
{
    int i, numplayers;
    char buf[MAX_INFO_STRING];
    static int maxclients;

    if (!maxclients)
        maxclients = Cvar_VariableIntegerValue("sv_maxclients");

    numplayers = 0;
    for (i = 0; i < maxclients && i < MAX_CLIENTS; i++)
    {
        SV_SetConfigstring(CS_PLAYERS+i, buf);
        //if no config string or no name
        if (!strlen(buf) || !strlen(Info_ValueForKey(buf, "n"))) continue;
        //skip spectators
        if (atoi(Info_ValueForKey(buf, "t")) == TEAM_SPECTATOR) continue;
        //
        if (BotSameTeam(bs, i))
        {
            numplayers++;
        }
    }
    return numplayers;
}

/*
==================
BotClientTravelTimeToGoal
==================
*/
int BotClientTravelTimeToGoal(int client, bot_goal_t *goal)
{
    playerState_t ps;
    int areanum;

    BotAI_GetClientState(client, &ps);
    areanum = BotPointAreaNum(ps.origin);
    if (!areanum) return 1;
    return botlib_export->aas.AAS_AreaTravelTimeToGoalArea(areanum, ps.origin, goal->areanum, TFL_DEFAULT);
}

/*
==================
BotSortTeamMatesByBaseTravelTime
==================
*/
int BotSortTeamMatesByBaseTravelTime(bot_state_t *bs, int *teammates, int maxteammates)
{

    int i, j, k, numteammates, traveltime;
    char buf[MAX_INFO_STRING];
    static int maxclients;
    int traveltimes[MAX_CLIENTS];
    bot_goal_t *goal = NULL;

    if (gametype == GT_CTF || gametype == GT_1FCTF)
    {
        if (BotTeam(bs) == TEAM_RED)
            goal = &ctf_redflag;
        else
            goal = &ctf_blueflag;
    }
    if (!maxclients)
        maxclients = Cvar_VariableIntegerValue("sv_maxclients");

    numteammates = 0;
    for (i = 0; i < maxclients && i < MAX_CLIENTS; i++)
    {
        SV_SetConfigstring(CS_PLAYERS+i, buf);
        //if no config string or no name
        if (!strlen(buf) || !strlen(Info_ValueForKey(buf, "n"))) continue;
        //skip spectators
        if (atoi(Info_ValueForKey(buf, "t")) == TEAM_SPECTATOR) continue;
        //
        if (BotSameTeam(bs, i))
        {
            //
            traveltime = BotClientTravelTimeToGoal(i, goal);
            //
            for (j = 0; j < numteammates; j++)
            {
                if (traveltime < traveltimes[j])
                {
                    for (k = numteammates; k > j; k--)
                    {
                        traveltimes[k] = traveltimes[k-1];
                        teammates[k] = teammates[k-1];
                    }
                    break;
                }
            }
            traveltimes[j] = traveltime;
            teammates[j] = i;
            numteammates++;
            if (numteammates >= maxteammates) break;
        }
    }
    return numteammates;
}

/*
==================
BotSetTeamMateTaskPreference
==================
*/
void BotSetTeamMateTaskPreference(bot_state_t *bs, int teammate, int preference)
{
    char teammatename[MAX_NETNAME];

    ctftaskpreferences[teammate].preference = preference;
    ClientName(teammate, teammatename, sizeof(teammatename));
    strcpy(ctftaskpreferences[teammate].name, teammatename);
}

/*
==================
BotGetTeamMateTaskPreference
==================
*/
int BotGetTeamMateTaskPreference(bot_state_t *bs, int teammate)
{
    char teammatename[MAX_NETNAME];

    if (!ctftaskpreferences[teammate].preference) return 0;
    ClientName(teammate, teammatename, sizeof(teammatename));
    if (Q_stricmp(teammatename, ctftaskpreferences[teammate].name)) return 0;
    return ctftaskpreferences[teammate].preference;
}

/*
==================
BotSortTeamMatesByTaskPreference
==================
*/
int BotSortTeamMatesByTaskPreference(bot_state_t *bs, int *teammates, int numteammates)
{
    int defenders[MAX_CLIENTS], numdefenders;
    int attackers[MAX_CLIENTS], numattackers;
    int roamers[MAX_CLIENTS], numroamers;
    int i, preference;

    numdefenders = numattackers = numroamers = 0;
    for (i = 0; i < numteammates; i++)
    {
        preference = BotGetTeamMateTaskPreference(bs, teammates[i]);
        if (preference & TEAMTP_DEFENDER)
        {
            defenders[numdefenders++] = teammates[i];
        }
        else if (preference & TEAMTP_ATTACKER)
        {
            attackers[numattackers++] = teammates[i];
        }
        else
        {
            roamers[numroamers++] = teammates[i];
        }
    }
    numteammates = 0;
    //defenders at the front of the list
    memcpy(&teammates[numteammates], defenders, numdefenders * sizeof(int));
    numteammates += numdefenders;
    //roamers in the middle
    memcpy(&teammates[numteammates], roamers, numroamers * sizeof(int));
    numteammates += numroamers;
    //attacker in the back of the list
    memcpy(&teammates[numteammates], attackers, numattackers * sizeof(int));
    numteammates += numattackers;

    return numteammates;
}

/*
==================
BotSayTeamOrders
==================
*/
void BotSayTeamOrderAlways(bot_state_t *bs, int toclient)
{
    char teamchat[MAX_MESSAGE_SIZE];
    char buf[MAX_MESSAGE_SIZE];
    char name[MAX_NETNAME];

    //if the bot is talking to itself
    if (bs->client == toclient)
    {
        //don't show the message just put it in the console message queue
        botlib_export->ai.BotGetChatMessage(bs->cs, buf, sizeof(buf));
        ClientName(bs->client, name, sizeof(name));
        Com_sprintf(teamchat, sizeof(teamchat), EC"(%s"EC")"EC": %s", name, buf);
        botlib_export->ai.BotQueueConsoleMessage(bs->cs, CMS_CHAT, teamchat);
    }
    else
    {
        botlib_export->ai.BotEnterChat(bs->cs, toclient, CHAT_TELL);
    }
}

/*
==================
BotSayTeamOrders
==================
*/
void BotSayTeamOrder(bot_state_t *bs, int toclient)
{
    BotSayTeamOrderAlways(bs, toclient);
}

/*
==================
BotVoiceChat
==================
*/
void BotVoiceChat(bot_state_t *bs, int toclient, char *voicechat)
{
}

/*
==================
BotVoiceChatOnly
==================
*/
void BotVoiceChatOnly(bot_state_t *bs, int toclient, char *voicechat)
{
}

/*
==================
BotSayVoiceTeamOrder
==================
*/
void BotSayVoiceTeamOrder(bot_state_t *bs, int toclient, char *voicechat)
{
}

/*
==================
BotCTFOrders
==================
*/
void BotCTFOrders_BothFlagsNotAtBase(bot_state_t *bs)
{
    int numteammates, defenders, attackers, i, other;
    int teammates[MAX_CLIENTS];
    char name[MAX_NETNAME], carriername[MAX_NETNAME];

    numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
    BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
    //different orders based on the number of team mates
    switch(bs->numteammates)
    {
    case 1:
        break;
    case 2:
        {
            //tell the one not carrying the flag to attack the enemy base
            if (teammates[0] != bs->flagcarrier) other = teammates[0];
            else other = teammates[1];
            ClientName(other, name, sizeof(name));
            BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
            BotSayTeamOrder(bs, other);
            BotSayVoiceTeamOrder(bs, other, VOICECHAT_GETFLAG);
            break;
        }
    case 3:
        {
            //tell the one closest to the base not carrying the flag to accompany the flag carrier
            if (teammates[0] != bs->flagcarrier) other = teammates[0];
            else other = teammates[1];
            ClientName(other, name, sizeof(name));
            if ( bs->flagcarrier != -1 )
            {
                ClientName(bs->flagcarrier, carriername, sizeof(carriername));
                if (bs->flagcarrier == bs->client)
                {
                    BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
                    BotSayVoiceTeamOrder(bs, other, VOICECHAT_FOLLOWME);
                }
                else
                {
                    BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
                    BotSayVoiceTeamOrder(bs, other, VOICECHAT_FOLLOWFLAGCARRIER);
                }
            }
            else
            {
                //
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayVoiceTeamOrder(bs, other, VOICECHAT_GETFLAG);
            }
            BotSayTeamOrder(bs, other);
            //tell the one furthest from the the base not carrying the flag to get the enemy flag
            if (teammates[2] != bs->flagcarrier) other = teammates[2];
            else other = teammates[1];
            ClientName(other, name, sizeof(name));
            BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
            BotSayTeamOrder(bs, other);
            BotSayVoiceTeamOrder(bs, other, VOICECHAT_RETURNFLAG);
            break;
        }
    default:
        {
            defenders = (int)((float) numteammates * 0.4 + 0.5);
            if (defenders > 4) defenders = 4;
            attackers = (int)((float) numteammates * 0.5 + 0.5);
            if (attackers > 5) attackers = 5;
            if (bs->flagcarrier != -1)
            {
                ClientName(bs->flagcarrier, carriername, sizeof(carriername));
                for (i = 0; i < defenders; i++)
                {
                    //
                    if (teammates[i] == bs->flagcarrier)
                    {
                        continue;
                    }
                    //
                    ClientName(teammates[i], name, sizeof(name));
                    if (bs->flagcarrier == bs->client)
                    {
                        BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
                        BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_FOLLOWME);
                    }
                    else
                    {
                        BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
                        BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_FOLLOWFLAGCARRIER);
                    }
                    BotSayTeamOrder(bs, teammates[i]);
                }
            }
            else
            {
                for (i = 0; i < defenders; i++)
                {
                    //
                    if (teammates[i] == bs->flagcarrier)
                    {
                        continue;
                    }
                    //
                    ClientName(teammates[i], name, sizeof(name));
                    BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                    BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_GETFLAG);
                    BotSayTeamOrder(bs, teammates[i]);
                }
            }
            for (i = 0; i < attackers; i++)
            {
                //
                if (teammates[numteammates - i - 1] == bs->flagcarrier)
                {
                    continue;
                }
                //
                ClientName(teammates[numteammates - i - 1], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
                BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_RETURNFLAG);
            }
            //
            break;
        }
    }
}

/*
==================
BotCTFOrders
==================
*/
void BotCTFOrders_FlagNotAtBase(bot_state_t *bs)
{
    int numteammates, defenders, attackers, i;
    int teammates[MAX_CLIENTS];
    char name[MAX_NETNAME];

    numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
    BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
    //passive strategy
    if (!(bs->ctfstrategy & CTFS_AGRESSIVE))
    {
        //different orders based on the number of team mates
        switch(bs->numteammates)
        {
        case 1:
            break;
        case 2:
            {
                //both will go for the enemy flag
                ClientName(teammates[0], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                BotSayTeamOrder(bs, teammates[0]);
                BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_GETFLAG);
                //
                ClientName(teammates[1], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[1]);
                BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
                break;
            }
        case 3:
            {
                //keep one near the base for when the flag is returned
                ClientName(teammates[0], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                BotSayTeamOrder(bs, teammates[0]);
                BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
                //the other two get the flag
                ClientName(teammates[1], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[1]);
                BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
                //
                ClientName(teammates[2], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[2]);
                BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
                break;
            }
        default:
            {
                //keep some people near the base for when the flag is returned
                defenders = (int)((float) numteammates * 0.3 + 0.5);
                if (defenders > 3) defenders = 3;
                attackers = (int)((float) numteammates * 0.7 + 0.5);
                if (attackers > 6) attackers = 6;
                for (i = 0; i < defenders; i++)
                {
                    //
                    ClientName(teammates[i], name, sizeof(name));
                    BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                    BotSayTeamOrder(bs, teammates[i]);
                    BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
                }
                for (i = 0; i < attackers; i++)
                {
                    //
                    ClientName(teammates[numteammates - i - 1], name, sizeof(name));
                    BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                    BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
                    BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_GETFLAG);
                }
                //
                break;
            }
        }
    }
    else
    {
        //different orders based on the number of team mates
        switch(bs->numteammates)
        {
        case 1:
            break;
        case 2:
            {
                //both will go for the enemy flag
                ClientName(teammates[0], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[0]);
                BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_GETFLAG);
                //
                ClientName(teammates[1], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[1]);
                BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
                break;
            }
        case 3:
            {
                //everyone go for the flag
                ClientName(teammates[0], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                BotSayTeamOrder(bs, teammates[0]);
                BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_GETFLAG);
                //
                ClientName(teammates[1], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[1]);
                BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
                //
                ClientName(teammates[2], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[2]);
                BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
                break;
            }
        default:
            {
                //keep some people near the base for when the flag is returned
                defenders = (int)((float) numteammates * 0.2 + 0.5);
                if (defenders > 2) defenders = 2;
                attackers = (int)((float) numteammates * 0.7 + 0.5);
                if (attackers > 7) attackers = 7;
                for (i = 0; i < defenders; i++)
                {
                    //
                    ClientName(teammates[i], name, sizeof(name));
                    BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                    BotSayTeamOrder(bs, teammates[i]);
                    BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
                }
                for (i = 0; i < attackers; i++)
                {
                    //
                    ClientName(teammates[numteammates - i - 1], name, sizeof(name));
                    BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                    BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
                    BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
                }
                //
                break;
            }
        }
    }
}

/*
==================
BotCTFOrders
==================
*/
void BotCTFOrders_EnemyFlagNotAtBase(bot_state_t *bs)
{
    int numteammates, defenders, attackers, i, other;
    int teammates[MAX_CLIENTS];
    char name[MAX_NETNAME], carriername[MAX_NETNAME];

    numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
    BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
    //different orders based on the number of team mates
    switch(numteammates)
    {
    case 1:
        break;
    case 2:
        {
            //tell the one not carrying the flag to defend the base
            if (teammates[0] == bs->flagcarrier) other = teammates[1];
            else other = teammates[0];
            ClientName(other, name, sizeof(name));
            BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
            BotSayTeamOrder(bs, other);
            BotSayVoiceTeamOrder(bs, other, VOICECHAT_DEFEND);
            break;
        }
    case 3:
        {
            //tell the one closest to the base not carrying the flag to defend the base
            if (teammates[0] != bs->flagcarrier) other = teammates[0];
            else other = teammates[1];
            ClientName(other, name, sizeof(name));
            BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
            BotSayTeamOrder(bs, other);
            BotSayVoiceTeamOrder(bs, other, VOICECHAT_DEFEND);
            //tell the other also to defend the base
            if (teammates[2] != bs->flagcarrier) other = teammates[2];
            else other = teammates[1];
            ClientName(other, name, sizeof(name));
            BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
            BotSayTeamOrder(bs, other);
            BotSayVoiceTeamOrder(bs, other, VOICECHAT_DEFEND);
            break;
        }
    default:
        {
            //60% will defend the base
            defenders = (int)((float) numteammates * 0.6 + 0.5);
            if (defenders > 6) defenders = 6;
            //30% accompanies the flag carrier
            attackers = (int)((float) numteammates * 0.3 + 0.5);
            if (attackers > 3) attackers = 3;
            for (i = 0; i < defenders; i++)
            {
                //
                if (teammates[i] == bs->flagcarrier)
                {
                    continue;
                }
                ClientName(teammates[i], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                BotSayTeamOrder(bs, teammates[i]);
                BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
            }
            // if we have a flag carrier
            if ( bs->flagcarrier != -1 )
            {
                ClientName(bs->flagcarrier, carriername, sizeof(carriername));
                for (i = 0; i < attackers; i++)
                {
                    //
                    if (teammates[numteammates - i - 1] == bs->flagcarrier)
                    {
                        continue;
                    }
                    //
                    ClientName(teammates[numteammates - i - 1], name, sizeof(name));
                    if (bs->flagcarrier == bs->client)
                    {
                        BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
                        BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_FOLLOWME);
                    }
                    else
                    {
                        BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
                        BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_FOLLOWFLAGCARRIER);
                    }
                    BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
                }
            }
            else
            {
                for (i = 0; i < attackers; i++)
                {
                    //
                    if (teammates[numteammates - i - 1] == bs->flagcarrier)
                    {
                        continue;
                    }
                    //
                    ClientName(teammates[numteammates - i - 1], name, sizeof(name));
                    BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                    BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
                    BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
                }
            }
            //
            break;
        }
    }
}


/*
==================
BotCTFOrders
==================
*/
void BotCTFOrders_BothFlagsAtBase(bot_state_t *bs)
{
    int numteammates, defenders, attackers, i;
    int teammates[MAX_CLIENTS];
    char name[MAX_NETNAME];

    //sort team mates by travel time to base
    numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
    //sort team mates by CTF preference
    BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
    //passive strategy
    if (!(bs->ctfstrategy & CTFS_AGRESSIVE))
    {
        //different orders based on the number of team mates
        switch(numteammates)
        {
        case 1:
            break;
        case 2:
            {
                //the one closest to the base will defend the base
                ClientName(teammates[0], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                BotSayTeamOrder(bs, teammates[0]);
                BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
                //the other will get the flag
                ClientName(teammates[1], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[1]);
                BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
                break;
            }
        case 3:
            {
                //the one closest to the base will defend the base
                ClientName(teammates[0], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                BotSayTeamOrder(bs, teammates[0]);
                BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
                //the second one closest to the base will defend the base
                ClientName(teammates[1], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                BotSayTeamOrder(bs, teammates[1]);
                BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_DEFEND);
                //the other will get the flag
                ClientName(teammates[2], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[2]);
                BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
                break;
            }
        default:
            {
                defenders = (int)((float) numteammates * 0.5 + 0.5);
                if (defenders > 5) defenders = 5;
                attackers = (int)((float) numteammates * 0.4 + 0.5);
                if (attackers > 4) attackers = 4;
                for (i = 0; i < defenders; i++)
                {
                    //
                    ClientName(teammates[i], name, sizeof(name));
                    BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                    BotSayTeamOrder(bs, teammates[i]);
                    BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
                }
                for (i = 0; i < attackers; i++)
                {
                    //
                    ClientName(teammates[numteammates - i - 1], name, sizeof(name));
                    BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                    BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
                    BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
                }
                //
                break;
            }
        }
    }
    else
    {
        //different orders based on the number of team mates
        switch(numteammates)
        {
        case 1:
            break;
        case 2:
            {
                //the one closest to the base will defend the base
                ClientName(teammates[0], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                BotSayTeamOrder(bs, teammates[0]);
                BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
                //the other will get the flag
                ClientName(teammates[1], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[1]);
                BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
                break;
            }
        case 3:
            {
                //the one closest to the base will defend the base
                ClientName(teammates[0], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                BotSayTeamOrder(bs, teammates[0]);
                BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
                //the others should go for the enemy flag
                ClientName(teammates[1], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[1]);
                BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
                //
                ClientName(teammates[2], name, sizeof(name));
                BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                BotSayTeamOrder(bs, teammates[2]);
                BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
                break;
            }
        default:
            {
                defenders = (int)((float) numteammates * 0.4 + 0.5);
                if (defenders > 4) defenders = 4;
                attackers = (int)((float) numteammates * 0.5 + 0.5);
                if (attackers > 5) attackers = 5;
                for (i = 0; i < defenders; i++)
                {
                    //
                    ClientName(teammates[i], name, sizeof(name));
                    BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
                    BotSayTeamOrder(bs, teammates[i]);
                    BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
                }
                for (i = 0; i < attackers; i++)
                {
                    //
                    ClientName(teammates[numteammates - i - 1], name, sizeof(name));
                    BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
                    BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
                    BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
                }
                //
                break;
            }
        }
    }
}

/*
==================
BotCTFOrders
==================
*/
void BotCTFOrders(bot_state_t *bs)
{
    int flagstatus;

    //
    if (BotTeam(bs) == TEAM_RED) flagstatus = bs->redflagstatus * 2 + bs->blueflagstatus;
    else flagstatus = bs->blueflagstatus * 2 + bs->redflagstatus;
    //
    switch(flagstatus)
    {
    case 0:
        BotCTFOrders_BothFlagsAtBase(bs);
        break;
    case 1:
        BotCTFOrders_EnemyFlagNotAtBase(bs);
        break;
    case 2:
        BotCTFOrders_FlagNotAtBase(bs);
        break;
    case 3:
        BotCTFOrders_BothFlagsNotAtBase(bs);
        break;
    }
}


/*
==================
BotCreateGroup
==================
*/
void BotCreateGroup(bot_state_t *bs, int *teammates, int groupsize)
{
    char name[MAX_NETNAME], leadername[MAX_NETNAME];
    int i;

    // the others in the group will follow the teammates[0]
    ClientName(teammates[0], leadername, sizeof(leadername));
    for (i = 1; i < groupsize; i++)
    {
        ClientName(teammates[i], name, sizeof(name));
        if (teammates[0] == bs->client)
        {
            BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
        }
        else
        {
            BotAI_BotInitialChat(bs, "cmd_accompany", name, leadername, NULL);
        }
        BotSayTeamOrderAlways(bs, teammates[i]);
    }
}

/*
==================
BotTeamOrders
 
  FIXME: defend key areas?
==================
*/
void BotTeamOrders(bot_state_t *bs)
{
    int teammates[MAX_CLIENTS];
    int numteammates, i;
    char buf[MAX_INFO_STRING];
    static int maxclients;

    if (!maxclients)
        maxclients = Cvar_VariableIntegerValue("sv_maxclients");

    numteammates = 0;
    for (i = 0; i < maxclients && i < MAX_CLIENTS; i++)
    {
        SV_GetConfigstring(CS_PLAYERS+i, buf, sizeof(buf));
        //if no config string or no name
        if (!strlen(buf) || !strlen(Info_ValueForKey(buf, "n"))) continue;
        //skip spectators
        if (atoi(Info_ValueForKey(buf, "t")) == TEAM_SPECTATOR) continue;
        //
        if (BotSameTeam(bs, i))
        {
            teammates[numteammates] = i;
            numteammates++;
        }
    }
    //
    switch(numteammates)
    {
    case 1:
        break;
    case 2:
        {
            //nothing special
            break;
        }
    case 3:
        {
            //have one follow another and one free roaming
            BotCreateGroup(bs, teammates, 2);
            break;
        }
    case 4:
        {
            BotCreateGroup(bs, teammates, 2);		//a group of 2
            BotCreateGroup(bs, &teammates[2], 2);	//a group of 2
            break;
        }
    case 5:
        {
            BotCreateGroup(bs, teammates, 2);		//a group of 2
            BotCreateGroup(bs, &teammates[2], 3);	//a group of 3
            break;
        }
    default:
        {
            if (numteammates <= 10)
            {
                for (i = 0; i < numteammates / 2; i++)
                {
                    BotCreateGroup(bs, &teammates[i*2], 2);	//groups of 2
                }
            }
            break;
        }
    }
}

/*
==================
FindHumanTeamLeader
==================
*/
int FindHumanTeamLeader(bot_state_t *bs)
{
    int i;

    for (i = 0; i < MAX_CLIENTS; i++)
    {
        if ( g_entities[i].inuse )
        {
            // if this player is not a bot
            if ( !(g_entities[i].r.svFlags & SVF_BOT) )
            {
                // if this player is ok with being the leader
                if (!notleader[i])
                {
                    // if this player is on the same team
                    if ( BotSameTeam(bs, i) )
                    {
                        ClientName(i, bs->teamleader, sizeof(bs->teamleader));
                        // if not yet ordered to do anything
                        if ( !BotSetLastOrderedTask(bs) )
                        {
                            // go on defense by default
                            BotVoiceChat_Defend(bs, i, SAY_TELL);
                        }
                        return qtrue;
                    }
                }
            }
        }
    }
    return qfalse;
}

/*
==================
BotTeamAI
==================
*/
void BotTeamAI(bot_state_t *bs)
{
    int numteammates;
    char netname[MAX_NETNAME];

    //
    if ( gametype < GT_TEAM  )
        return;
    // make sure we've got a valid team leader
    if (!BotValidTeamLeader(bs))
    {
        //
        if (!FindHumanTeamLeader(bs))
        {
            //
            if (!bs->askteamleader_time && !bs->becometeamleader_time)
            {
                if (bs->entergame_time + 10 > FloatTime())
                {
                    bs->askteamleader_time = FloatTime() + 5 + random() * 10;
                }
                else
                {
                    bs->becometeamleader_time = FloatTime() + 5 + random() * 10;
                }
            }
            if (bs->askteamleader_time && bs->askteamleader_time < FloatTime())
            {
                // if asked for a team leader and no response
                BotAI_BotInitialChat(bs, "whoisteamleader", NULL);
                botlib_export->ai.BotEnterChat(bs->cs, 0, CHAT_TEAM);
                bs->askteamleader_time = 0;
                bs->becometeamleader_time = FloatTime() + 8 + random() * 10;
            }
            if (bs->becometeamleader_time && bs->becometeamleader_time < FloatTime())
            {
                BotAI_BotInitialChat(bs, "iamteamleader", NULL);
                botlib_export->ai.BotEnterChat(bs->cs, 0, CHAT_TEAM);
                BotSayVoiceTeamOrder(bs, -1, VOICECHAT_STARTLEADER);
                ClientName(bs->client, netname, sizeof(netname));
                strncpy(bs->teamleader, netname, sizeof(bs->teamleader));
                bs->teamleader[sizeof(bs->teamleader)] = '\0';
                bs->becometeamleader_time = 0;
            }
            return;
        }
    }
    bs->askteamleader_time = 0;
    bs->becometeamleader_time = 0;

    //return if this bot is NOT the team leader
    ClientName(bs->client, netname, sizeof(netname));
    if (Q_stricmp(netname, bs->teamleader) != 0) return;
    //
    numteammates = BotNumTeamMates(bs);
    //give orders
    switch(gametype)
    {
    case GT_TEAM:
        {
            if (bs->numteammates != numteammates || bs->forceorders)
            {
                bs->teamgiveorders_time = FloatTime();
                bs->numteammates = numteammates;
                bs->forceorders = qfalse;
            }
            //if it's time to give orders
            if (bs->teamgiveorders_time && bs->teamgiveorders_time < FloatTime() - 5)
            {
                BotTeamOrders(bs);
                //give orders again after 120 seconds
                bs->teamgiveorders_time = FloatTime() + 120;
            }
            break;
        }
    case GT_CTF:
        {
            //if the number of team mates changed or the flag status changed
            //or someone wants to know what to do
            if (bs->numteammates != numteammates || bs->flagstatuschanged || bs->forceorders)
            {
                bs->teamgiveorders_time = FloatTime();
                bs->numteammates = numteammates;
                bs->flagstatuschanged = qfalse;
                bs->forceorders = qfalse;
            }
            //if there were no flag captures the last 3 minutes
            if (bs->lastflagcapture_time < FloatTime() - 240)
            {
                bs->lastflagcapture_time = FloatTime();
                //randomly change the CTF strategy
                if (random() < 0.4)
                {
                    bs->ctfstrategy ^= CTFS_AGRESSIVE;
                    bs->teamgiveorders_time = FloatTime();
                }
            }
            //if it's time to give orders
            if (bs->teamgiveorders_time && bs->teamgiveorders_time < FloatTime() - 3)
            {
                BotCTFOrders(bs);
                //
                bs->teamgiveorders_time = 0;
            }
            break;
        }
    }
}

